Vienlaicīguma atbloķēšana Python: ThreadPoolExecutor pret ProcessPoolExecutor

Python, lai arī daudzpusīga un plaši izmantota programmēšanas valoda, saskaras ar noteiktiem ierobežojumiem attiecībā uz patiesu paralēlismu Globālā interpretatora bloķētāja (GIL) dēļ. concurrent.futures modulis nodrošina augsta līmeņa saskarni asinhronai izsaucamo objektu (callables) izpildei, piedāvājot veidu, kā apiet dažus no šiem ierobežojumiem un uzlabot veiktspēju noteikta veida uzdevumiem. Šis modulis nodrošina divas galvenās klases: ThreadPoolExecutor un ProcessPoolExecutor. Šajā visaptverošajā ceļvedī tiks apskatītas abas, izceļot to atšķirības, stiprās un vājās puses, kā arī sniedzot praktiskus piemērus, kas palīdzēs jums izvēlēties pareizo izpildītāju savām vajadzībām.

Vienlaicīguma un paralēlisma izpratne

Pirms iedziļināties katra izpildītāja specifikā, ir svarīgi izprast vienlaicīguma un paralēlisma jēdzienus. Šie termini bieži tiek lietoti kā sinonīmi, taču tiem ir atšķirīgas nozīmes:

• Vienlaicīgums (Concurrency): Nodarbojas ar vairāku uzdevumu pārvaldību vienlaikus. Tas ir par koda strukturēšanu tā, lai apstrādātu vairākas lietas šķietami vienlaicīgi, pat ja tās faktiski tiek pārmaiņus izpildītas uz viena procesora kodola. Iedomājieties to kā šefpavāru, kurš pārvalda vairākus katlus uz vienas plīts – tie visi nevārās precīzi vienā un tajā pašā brīdī, bet šefpavārs tos visus pārvalda.
• Paralēlisms (Parallelism): Ietver vairāku uzdevumu faktisku izpildi *vienā un tajā pašā* laikā, parasti izmantojot vairākus procesora kodolus. Tas ir kā vairāki šefpavāri, katrs vienlaicīgi strādā pie citas ēdiena daļas.

Python GIL lielā mērā novērš patiesu paralēlismu CPU saistītiem uzdevumiem, izmantojot pavedienus. Tas ir tāpēc, ka GIL ļauj tikai vienam pavedienam vienlaikus kontrolēt Python interpretatoru. Tomēr I/O saistītiem uzdevumiem, kur programma lielāko daļu laika pavada, gaidot ārējas operācijas, piemēram, tīkla pieprasījumus vai diska nolasīšanu, pavedieni joprojām var nodrošināt ievērojamus veiktspējas uzlabojumus, ļaujot citiem pavedieniem darboties, kamēr viens gaida.

Iepazīstinām ar `concurrent.futures` moduli

concurrent.futures modulis vienkāršo uzdevumu asinhronas izpildes procesu. Tas nodrošina augsta līmeņa saskarni darbam ar pavedieniem un procesiem, abstrahējot lielu daļu sarežģītības, kas saistīta ar to tiešu pārvaldību. Galvenais jēdziens ir "izpildītājs" (executor), kas pārvalda iesniegto uzdevumu izpildi. Divi galvenie izpildītāji ir:

• ThreadPoolExecutor: Izmanto pavedienu kopu (pool) uzdevumu izpildei. Piemērots I/O saistītiem uzdevumiem.
• ProcessPoolExecutor: Izmanto procesu kopu uzdevumu izpildei. Piemērots CPU saistītiem uzdevumiem.

ThreadPoolExecutor: Pavedienu izmantošana I/O saistītiem uzdevumiem

ThreadPoolExecutor izveido darba pavedienu kopu uzdevumu izpildei. GIL dēļ pavedieni nav ideāli skaitļošanas intensīvām operācijām, kas gūst labumu no patiesa paralēlisma. Tomēr tie ir lieliski piemēroti I/O saistītiem scenārijiem. Apskatīsim, kā to izmantot:

Pamata lietošana

Šeit ir vienkāršs piemērs, kā izmantot ThreadPoolExecutor, lai vienlaicīgi lejupielādētu vairākas tīmekļa lapas:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Submit each URL to the executor
    futures = [executor.submit(download_page, url) for url in urls]

    # Wait for all tasks to complete
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

Paskaidrojums:

1. Mēs importējam nepieciešamos moduļus: concurrent.futures, requests un time.
2. Mēs definējam sarakstu ar URL, kurus lejupielādēt.
3. Funkcija download_page iegūst saturu no norādītā URL. Kļūdu apstrāde ir iekļauta, izmantojot `try...except` un `response.raise_for_status()`, lai notvertu iespējamās tīkla problēmas.
4. Mēs izveidojam ThreadPoolExecutor ar maksimāli 4 darba pavedieniem. Arguments max_workers kontrolē maksimālo pavedienu skaitu, ko var izmantot vienlaicīgi. Pārāk augstas vērtības iestatīšana ne vienmēr uzlabos veiktspēju, īpaši I/O saistītiem uzdevumiem, kur tīkla joslas platums bieži ir vājais posms.
5. Mēs izmantojam saraksta izpratni (list comprehension), lai iesniegtu katru URL izpildītājam, izmantojot executor.submit(download_page, url). Tas atgriež Future objektu katram uzdevumam.
6. Funkcija concurrent.futures.as_completed(futures) atgriež iteratoru, kas atgriež "futures", tiklīdz tie ir pabeigti. Tas ļauj izvairīties no gaidīšanas, kamēr visi uzdevumi pabeigti, pirms rezultātu apstrādes.
7. Mēs iterējam cauri pabeigtajiem "futures" un iegūstam katra uzdevuma rezultātu, izmantojot future.result(), summējot kopējo lejupielādēto baitu skaitu. Kļūdu apstrāde funkcijā `download_page` nodrošina, ka atsevišķas kļūmes neaptur visu procesu.
8. Visbeidzot, mēs izdrukājam kopējo lejupielādēto baitu skaitu un patērēto laiku.

ThreadPoolExecutor priekšrocības

• Vienkāršots vienlaicīgums: Nodrošina tīru un viegli lietojamu saskarni pavedienu pārvaldībai.
• I/O saistītu uzdevumu veiktspēja: Lieliski piemērots uzdevumiem, kas pavada ievērojamu laiku, gaidot I/O operācijas, piemēram, tīkla pieprasījumus, failu lasīšanu vai datu bāzes vaicājumus.
• Samazinātas pieskaitāmās izmaksas: Pavedieniem parasti ir zemākas pieskaitāmās izmaksas salīdzinājumā ar procesiem, padarot tos efektīvākus uzdevumiem, kas ietver biežu konteksta pārslēgšanu.

ThreadPoolExecutor ierobežojumi

• GIL ierobežojums: GIL ierobežo patiesu paralēlismu CPU saistītiem uzdevumiem. Vienlaikus Python baitu kodu var izpildīt tikai viens pavediens, kas mazina vairāku kodolu priekšrocības.
• Atkļūdošanas sarežģītība: Vairāku pavedienu lietojumprogrammu atkļūdošana var būt sarežģīta sacensību apstākļu (race conditions) un citu ar vienlaicīgumu saistītu problēmu dēļ.

ProcessPoolExecutor: Vairākprocesu apstrādes atbrīvošana CPU saistītiem uzdevumiem

ProcessPoolExecutor pārvar GIL ierobežojumu, izveidojot darba procesu kopu. Katram procesam ir savs Python interpretators un atmiņas telpa, kas nodrošina patiesu paralēlismu vairāku kodolu sistēmās. Tas padara to ideāli piemērotu CPU saistītiem uzdevumiem, kas ietver smagus aprēķinus.

Pamata lietošana

Apsveriet skaitļošanas intensīvu uzdevumu, piemēram, kvadrātu summas aprēķināšanu lielam skaitļu diapazonam. Lūk, kā izmantot ProcessPoolExecutor, lai paralelizētu šo uzdevumu:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Important for avoiding recursive spawning in some environments
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

Paskaidrojums:

1. Mēs definējam funkciju sum_of_squares, kas aprēķina kvadrātu summu noteiktam skaitļu diapazonam. Mēs iekļaujam `os.getpid()`, lai redzētu, kurš process izpilda katru diapazonu.
2. Mēs definējam diapazona lielumu un izmantojamo procesu skaitu. Saraksts ranges tiek izveidots, lai sadalītu kopējo aprēķinu diapazonu mazākos gabalos, pa vienam katram procesam.
3. Mēs izveidojam ProcessPoolExecutor ar norādīto darba procesu skaitu.
4. Mēs iesniedzam katru diapazonu izpildītājam, izmantojot executor.submit(sum_of_squares, start, end).
5. Mēs apkopojam rezultātus no katra "future", izmantojot future.result().
6. Mēs summējam rezultātus no visiem procesiem, lai iegūtu galīgo kopsummu.

Svarīga piezīme: Lietojot ProcessPoolExecutor, īpaši Windows vidē, kods, kas izveido izpildītāju, jāievieto if __name__ == "__main__": blokā. Tas novērš rekursīvu procesu radīšanu, kas var izraisīt kļūdas un neparedzētu uzvedību. Tas ir tāpēc, ka modulis tiek atkārtoti importēts katrā bērna procesā.

ProcessPoolExecutor priekšrocības

• Patiess paralēlisms: Pārvar GIL ierobežojumu, nodrošinot patiesu paralēlismu vairāku kodolu sistēmās CPU saistītiem uzdevumiem.
• Uzlabota veiktspēja CPU saistītiem uzdevumiem: Var sasniegt ievērojamus veiktspējas uzlabojumus skaitļošanas intensīvām operācijām.
• Robustums: Ja viens process avarē, tas ne vienmēr aptur visu programmu, jo procesi ir izolēti viens no otra.

ProcessPoolExecutor ierobežojumi

• Augstākas pieskaitāmās izmaksas: Procesu izveidei un pārvaldībai ir augstākas pieskaitāmās izmaksas salīdzinājumā ar pavedieniem.
• Starpprocesu komunikācija: Datu koplietošana starp procesiem var būt sarežģītāka un prasa starpprocesu komunikācijas (IPC) mehānismus, kas var palielināt pieskaitāmās izmaksas.
• Atmiņas patēriņš: Katram procesam ir sava atmiņas telpa, kas var palielināt lietojumprogrammas kopējo atmiņas patēriņu. Liela datu apjoma nodošana starp procesiem var kļūt par vājo posmu.

Pareizā izpildītāja izvēle: ThreadPoolExecutor pret ProcessPoolExecutor

Galvenais, lai izvēlētos starp ThreadPoolExecutor un ProcessPoolExecutor, ir izprast jūsu uzdevumu būtību:

• I/O saistīti uzdevumi: Ja jūsu uzdevumi lielāko daļu laika pavada, gaidot I/O operācijas (piem., tīkla pieprasījumus, failu lasīšanu, datu bāzes vaicājumus), ThreadPoolExecutor parasti ir labāka izvēle. Šajos scenārijos GIL ir mazāks šķērslis, un pavedienu zemākās pieskaitāmās izmaksas padara tos efektīvākus.
• CPU saistīti uzdevumi: Ja jūsu uzdevumi ir skaitļošanas intensīvi un izmanto vairākus kodolus, ProcessPoolExecutor ir pareizais ceļš. Tas apiet GIL ierobežojumu un nodrošina patiesu paralēlismu, kas noved pie ievērojamiem veiktspējas uzlabojumiem.

Šeit ir tabula, kas apkopo galvenās atšķirības:

Īpašība	ThreadPoolExecutor	ProcessPoolExecutor
Vienlaicīguma modelis	Vairākpavedienu apstrāde	Vairākprocesu apstrāde
GIL ietekme	Ierobežo GIL	Apiet GIL
Piemērots	I/O saistītiem uzdevumiem	CPU saistītiem uzdevumiem
Pieskaitāmās izmaksas	Zemākas	Augstākas
Atmiņas patēriņš	Zemāks	Augstāks
Starpprocesu komunikācija	Nav nepieciešama (pavedieni dala atmiņu)	Nepieciešama datu koplietošanai
Robustums	Mazāk robusts (avārija var ietekmēt visu procesu)	Robustāks (procesi ir izolēti)

Papildu metodes un apsvērumi

Uzdevumu iesniegšana ar argumentiem

Abi izpildītāji ļauj nodot argumentus izpildāmajai funkcijai. To dara, izmantojot submit() metodi:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

Izņēmumu apstrāde

Izņēmumi, kas radušies izpildītajā funkcijā, netiek automātiski nodoti galvenajam pavedienam vai procesam. Jums tie ir skaidri jāapstrādā, saņemot Future rezultātu:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

`map` izmantošana vienkāršiem uzdevumiem

Vienkāršiem uzdevumiem, kur vēlaties piemērot vienu un to pašu funkciju ievades secībai, map() metode nodrošina kodolīgu veidu, kā iesniegt uzdevumus:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

Darbinieku skaita kontrole

Arguments max_workers gan ThreadPoolExecutor, gan ProcessPoolExecutor kontrolē maksimālo pavedienu vai procesu skaitu, ko var izmantot vienlaicīgi. Pareizas max_workers vērtības izvēle ir svarīga veiktspējai. Labs sākumpunkts ir jūsu sistēmā pieejamo CPU kodolu skaits. Tomēr I/O saistītiem uzdevumiem var būt lietderīgi izmantot vairāk pavedienu nekā kodolu, jo pavedieni var pārslēgties uz citiem uzdevumiem, gaidot I/O. Lai noteiktu optimālo vērtību, bieži ir nepieciešama eksperimentēšana un profilēšana.

Progresa uzraudzība

concurrent.futures modulis nenodrošina iebūvētus mehānismus tiešai uzdevumu progresa uzraudzībai. Tomēr jūs varat ieviest savu progresa izsekošanu, izmantojot atzvanus (callbacks) vai koplietojamus mainīgos. Lai parādītu progresa joslas, var integrēt tādas bibliotēkas kā `tqdm`.

Reālās pasaules piemēri

Apskatīsim dažus reālās pasaules scenārijus, kur ThreadPoolExecutor un ProcessPoolExecutor var efektīvi pielietot:

• Tīmekļa datu iegūšana (Web Scraping): Vairāku tīmekļa lapu vienlaicīga lejupielāde un parsēšana, izmantojot ThreadPoolExecutor. Katrs pavediens var apstrādāt citu tīmekļa lapu, uzlabojot kopējo datu iegūšanas ātrumu. Esiet uzmanīgi ar vietņu lietošanas noteikumiem un izvairieties no to serveru pārslodzes.
• Attēlu apstrāde: Attēlu filtru vai transformāciju piemērošana lielam attēlu kopumam, izmantojot ProcessPoolExecutor. Katrs process var apstrādāt citu attēlu, izmantojot vairākus kodolus ātrākai apstrādei. Apsveriet tādas bibliotēkas kā OpenCV efektīvai attēlu manipulācijai.
• Datu analīze: Sarežģītu aprēķinu veikšana ar lielām datu kopām, izmantojot ProcessPoolExecutor. Katrs process var analizēt datu apakškopu, samazinot kopējo analīzes laiku. Pandas un NumPy ir populāras bibliotēkas datu analīzei Python.
• Mašīnmācīšanās: Mašīnmācīšanās modeļu apmācība, izmantojot ProcessPoolExecutor. Dažus mašīnmācīšanās algoritmus var efektīvi paralelizēt, nodrošinot ātrāku apmācības laiku. Tādas bibliotēkas kā scikit-learn un TensorFlow piedāvā atbalstu paralelizācijai.
• Video kodēšana: Video failu konvertēšana uz dažādiem formātiem, izmantojot ProcessPoolExecutor. Katrs process var kodēt citu video segmentu, padarot kopējo kodēšanas procesu ātrāku.

Globāli apsvērumi

Izstrādājot vienlaicīgas lietojumprogrammas globālai auditorijai, ir svarīgi ņemt vērā sekojošo:

• Laika joslas: Esiet uzmanīgi ar laika joslām, strādājot ar laika jutīgām operācijām. Izmantojiet tādas bibliotēkas kā pytz, lai apstrādātu laika joslu konvertācijas.
• Lokalizācijas (Locales): Nodrošiniet, ka jūsu lietojumprogramma pareizi apstrādā dažādas lokalizācijas. Izmantojiet tādas bibliotēkas kā locale, lai formatētu skaitļus, datumus un valūtas atbilstoši lietotāja lokalizācijai.
• Rakstzīmju kodējumi: Izmantojiet Unicode (UTF-8) kā noklusējuma rakstzīmju kodējumu, lai atbalstītu plašu valodu klāstu.
• Internacionalizācija (i18n) un lokalizācija (l10n): Projektējiet savu lietojumprogrammu tā, lai to būtu viegli internacionalizēt un lokalizēt. Izmantojiet gettext vai citas tulkošanas bibliotēkas, lai nodrošinātu tulkojumus dažādām valodām.
• Tīkla latentums: Apsveriet tīkla latentumu, sazinoties ar attāliem pakalpojumiem. Ieviesiet atbilstošus taimautus un kļūdu apstrādi, lai nodrošinātu, ka jūsu lietojumprogramma ir noturīga pret tīkla problēmām. Serveru ģeogrāfiskā atrašanās vieta var ievērojami ietekmēt latentumu. Apsveriet satura piegādes tīklu (CDN) izmantošanu, lai uzlabotu veiktspēju lietotājiem dažādos reģionos.

Noslēgums

concurrent.futures modulis nodrošina jaudīgu un ērtu veidu, kā ieviest vienlaicīgumu un paralēlismu jūsu Python lietojumprogrammās. Izprotot atšķirības starp ThreadPoolExecutor un ProcessPoolExecutor un rūpīgi apsverot savu uzdevumu būtību, jūs varat ievērojami uzlabot sava koda veiktspēju un atsaucību. Atcerieties profilēt savu kodu un eksperimentēt ar dažādām konfigurācijām, lai atrastu optimālos iestatījumus jūsu konkrētajam lietošanas gadījumam. Tāpat apzinieties GIL ierobežojumus un potenciālās sarežģītības, kas saistītas ar vairāku pavedienu un vairāku procesu programmēšanu. Ar rūpīgu plānošanu un ieviešanu jūs varat atraisīt visu Python vienlaicīguma potenciālu un izveidot robustas un mērogojamas lietojumprogrammas globālai auditorijai.